# automatic compilation of C++ source files of the test
	# this source file was modified, so it is a good time to check if it  ; \
	# has new header files dependencies                                   ; \

$(dir_test)/%.o : $(qt_test_hs) $(dir_test)/%.$(source_extension)
	$(show) ""                                                            ; \
	echo  "---------------------------------------- "                     ; \
	echo  "Compiling $<"                                                  ; \
	$(cxx) $(final_test_inc_dir) $(compile_flags) $(final_test_minus_d) $< -o $@     ;

#	$(make_cmd) dependencies class=test src_file=$< to_parse_file=$<       \
#	                          obj_dir="$(dir_test)"            ; \


# automatic regeneration of header code files from qt-designer '.ui' files
$(dir_test)/%.$(header_extension): $(dir_test)/%.ui
	$(show) ""                                                            ; \
	echo  "---------------------------------------- "                     ; \
	echo  "Generating $@ from  $<"                                        ; \
	uic $< -o $@                                                          ; 


# automatic regeneration of source test files from qt-designer '.ui' files
#$(dir_code)/test/%.$(source_extension): $(dir_code)/test/%.ui
#	$(show) ""                                                            ; \
#	echo  "---------------------------------------- "                     ; \
#	echo  "Generating $@ from  $<"                                       ; \
#	echo  "NOT IMPLEMENTED"                                              ; \
#	touch $@                                                             ;
#	uic -impl $(dir_code)/test/$*.$(header_extension) $< -o $@






# builds the test as a library
#test_build_lib:
#	$(show) ""                                                           ; \
#	$(shared_command) $(shared_prefix)$(project).test$(shared_sufix)       \
#                $(test_objs) $(final_test_static_libs) r     \
#                $(final_test_lib_dir) $(final_test_shared_libs)                \
#		$(search_lib_dir)                                            ; \
#	mv $(shared_prefix)$(project).test$(shared_sufix)                      \
#		$(dir_test)/$(coc)                               ; \
#	mkdir -p $(build_lib_dir) 2> /dev/null                               ; \
#	cp -f                                                                  \
#	$(dir_bin)/test/$(coc)/$(shared_prefix)$(project).test$(shared_sufix) \
#		$(build_lib_dir)  2> /dev/null                               ; 

# AQUI

# builds the test as a program
test_build_pgm:
	$(show) ""                                                           ; \
	echo "Building a program for $(project)"                             ; \
	$(program_command) $(program_prefix)$(project)_test$(program_sufix)    \
		$(test_objs) $(final_test_static_libs)                         \
		$(final_test_lib_dir) $(final_test_shared_libs)                \
		$(search_lib_dir)                                            ; \
	mv $(program_prefix)$(project)_test$(program_sufix) $(dir_bin)         \
                    2> /dev/null                                             ;  

# executes a target in all the Projects that the Test depend upon
test_chain:
	$(show) ""                                                           ; \
	refs=`echo "$(test_depends)" | tr -s " "`                            ; \
	refs=`echo "$$refs" | tr [:space:] "-"`                              ; \
	if [ ! -z $$refs ]; then                                               \
		cont_ref=1                                                   ; \
		ref=`echo $$refs | cut -d '-' -f$$cont_ref`                  ; \
		while [ ! -z "$$ref" ]; do                                     \
			make project="$$ref" coc=$(coc)        \
				verbose=$(verbose) target=$(target)            \
				chain_target=$(chain_target)                   \
				M_version=$(M_version) m_version=$(m_version)  \
				build_number=$(build_number)  chain          ; \
			make project="$$ref" coc=$(coc)        \
				verbose=$(verbose) target=$(target)            \
				M_version=$(M_version) m_version=$(m_version)  \
				build_number=$(build_number) $(chain_target) ; \
			cont_ref=`echo $$cont_ref+1 | bc`                    ; \
			ref1=`echo $$refs | cut -d '-' -f$$cont_ref`         ; \
			if [ "$$ref" = "$$ref1" -a $$cont_ref -eq 2 ] ; then   \
				ref=""                                       ; \
			else                                                   \
				ref=$$ref1                                   ; \
			fi                                                   ; \
		done                                                         ; \
	fi                                                                   ;

# Builds the code of all the Projects that the test depend upon
test_code_build_chain:
	$(show) ""                                                           ; \
	echo "********************************************* "                ; \
	echo "Building all the Projects that the test for Project $(project) depend on" ; \
	$(make_cmd) test_chain chain_target=code_build                       ; 

# Creates the necessary files to build the test as a program
test_as_pgm:

# Changes the 'project.mk' file in order to build the test as a library
test_as_lib_change_project_file:
	$(show) ""                                                           ; \
	tmp="$(dir_bin_tool)/.prj.mk"                                        ; \
	rm -f "$$tmp" 2> /dev/null                                           ; \
	# changing the project.mk to build a library                         ; \
	cat $(dir_bin_tool)/project.mk | while read line; do                   \
		# does this line contain a commented 'test_type=lib'?        ; \
		f=`expr match "$$line" '[#]test_type=lib'`                   ; \
		if [ "$$f" != "0" ]; then                                      \
			# yes, so uncomment it                               ; \
			new_line="test_type=lib"                             ; \
		else                                                           \
			# no                                                 ; \
			# does it contain a uncommented 'test_type=pgm'?     ; \
			f=`expr match "$$line" 'test_type=pgm'`              ; \
			if [ "$$f" != "0" ]; then                              \
				# yes, so comment it                         ; \
				new_line="#test_type=pgm" >> "$$tmp"         ; \
			else                                                   \
				# no                                         ; \
				# does it contain 'test_int_shared_libs'?    ; \
				f=`expr match "$$line" 'test_int_shared_libs'` ; \
				if [ "$$f" != 0 ]; then                        \
					# yes                                ; \
					new_line="$$line:= tenacitas.number tenacitas.tester tenacitas.log" ; \
				fi                                           ; \
			fi                                                   ; \
		fi                                                           ; \
		echo "$$new_line" >> "$$tmp"                                 ; \
	done                                                                 ; \
	mv "$$tmp" $(dir_bin_tool)/project.mk                                ; 



# Creates a file with a skeleton of code of how to write a test
test_as_lib_create_test_file:
	$(show) ""                                                           ; \
	# replacing the '.' for '_' in the $(project)                        ; \
	prj=`echo "$(project)" | sed 's/\./_/g'`                             ; \
	# assembling the namespace identifier                                ; \
	namespace_test="$$prj"_test                                          ; \
	# assembling the name of the header file                             ; \
	header_base_name="test_declaration"                                  ; \
	header_name=$$header_base_name".h"                                   ; \
	# assembling the full path of the header file                        ; \
	header_path="$(dir_code)/test/$$header_name"                         ; \
	# assembling the 'define' that goes in the beginning of the header   ; \
	header_def=_"$$prj__$$header_base_name"_h_                           ; \
	# writing to the header file  					     ; \
	echo "#ifndef $$header_def"                          > $$header_path ; \
	echo "#define $$header_def"                         >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "#include <tenacitas.tester/tester.h>"         >> $$header_path ; \
	echo "#include <tenacitas.number/fault.h>"          >> $$header_path ; \
	echo "#include <tenacitas.memory/ptr.h>"            >> $$header_path ; \
	echo "#include <tenacitas.log/logger.h>"            >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "using namespace std;"                         >> $$header_path ; \
	echo "using namespace tenacitas;"                   >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "namespace tenacitas {"                        >> $$header_path ; \
	echo "    /**"                                      >> $$header_path ; \
	echo "     This namespace contains tests for the @p $(project) project" >> $$header_path ; \
	echo "    */"                                       >> $$header_path ; \
	echo "    namespace $$namespace_test {"             >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "        /**"                                  >> $$header_path ; \
	echo "           Example test @p t000000"           >> $$header_path ; \
	echo "         */"                                  >> $$header_path ; \
	echo "        class t000000 : public tester::test {">> $$header_path ; \
	echo "        public:"                              >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            t000000 ( );"                     >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            /**"                              >> $$header_path ; \
	echo "               @copydoc tenacitas::tester::test::run at tenacitas.tester/tester.h" >> $$header_path ; \
	echo "             */"                              >> $$header_path ; \
	echo "            void run ( ) throw ( number::fault );"     >> $$header_path ; \
	echo "         };"                                  >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "        /**"                                  >> $$header_path ; \
	echo "           Example test @p t000001"           >> $$header_path ; \
	echo "         */"                                  >> $$header_path ; \
	echo "        class t000001 : public tester::test {">> $$header_path ; \
	echo "        public:"                              >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            t000001 ( );"                     >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            /**"                              >> $$header_path ; \
	echo "               @copydoc tenacitas::tester::test::run at tenacitas.tester/tester.h" >> $$header_path ; \
	echo "             */"                              >> $$header_path ; \
	echo "            void run ( ) throw ( number::fault );"     >> $$header_path ; \
	echo "         };"                                  >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "        /**"                                  >> $$header_path ; \
	echo "           Example test @p t000002"           >> $$header_path ; \
	echo "           This tenacitas::tester::test examples what shuld be done when a test fails" >> $$header_path ; \
	echo "         */"                                  >> $$header_path ; \
	echo "        class t000002 : public tester::test {">> $$header_path ; \
	echo "        public:"                              >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            t000002 ( );"                     >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            /**"                              >> $$header_path ; \
	echo "               This is the tenacitas::number::fault::code that will be throw to" >> $$header_path ; \
	echo "               inform that the tenacitas::tester::test failed" >> $$header_path ; \
	echo "             */"                              >> $$header_path ; \
	echo "            static const number::fault::code erro1;" >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "            /**"                              >> $$header_path ; \
	echo "               @copydoc tenacitas::tester::test::run at tenacitas.tester/tester.h" >> $$header_path ; \
	echo "             */"                              >> $$header_path ; \
	echo "            void run ( ) throw ( number::fault );"     >> $$header_path ; \
	echo "         };"                                  >> $$header_path ; \
	echo "    }"                                        >> $$header_path ; \
	echo "}"                                            >> $$header_path ; \
	echo ""                                             >> $$header_path ; \
	echo "#endif"                                       >> $$header_path ; \
	# assembling the name of the t000000.cpp                             ; \
	t0_cpp_name="t000000.cpp"                                            ; \
	t0_cpp_path="$(dir_code)/test/$$t0_cpp_name"                         ; \
	# writing to t000000.cpp                                             ; \
	echo "#include \"$$header_name\""                    > $$t0_cpp_path ; \
	echo ""                                            >> $$t0_cpp_path ; \
	echo "using namespace tenacitas::$$namespace_test;">> $$t0_cpp_path ; \
	echo ""                                            >> $$t0_cpp_path ; \
	echo ""                                            >> $$t0_cpp_path ; \
	echo "t000000::"                                   >> $$t0_cpp_path ; \
	echo "t000000 ( ) : "                              >> $$t0_cpp_path ; \
	echo "    tester::test ( \"t000000\", \"Basic test 0\" ) {} " >> $$t0_cpp_path ; \
	echo ""                                            >> $$t0_cpp_path ; \
	echo ""                                            >> $$t0_cpp_path ; \
	echo "void"                                        >> $$t0_cpp_path ; \
	echo "t000000::"                                   >> $$t0_cpp_path ; \
	echo "run ( ) throw ( number::fault )  { "        >> $$t0_cpp_path ; \
	echo ""                                            >>  $$t0_cpp_path ; \
	echo "    log_in (t000000) ;"                      >> $$t0_cpp_path ; \
	echo "                      "                      >> $$t0_cpp_path ; \
	echo "                      "                      >> $$t0_cpp_path ; \
	echo "                      "                      >> $$t0_cpp_path ; \
	echo "    log_out (t000000) ;"                      >> $$t0_cpp_path ; \
	echo "}"                                           >> $$t0_cpp_path ; \
	# assembling the name of the t000001.cpp                             ; \
	t1_cpp_name="t000001.cpp"                                            ; \
	t1_cpp_path="$(dir_code)/test/$$t1_cpp_name"                         ; \
	# writing to t000001.cpp                                             ; \
	echo "#include \"$$header_name\""                    > $$t1_cpp_path ; \
	echo ""                                            >> $$t1_cpp_path ; \
	echo "using namespace tenacitas::$$namespace_test;">> $$t1_cpp_path ; \
	echo ""                                            >> $$t1_cpp_path ; \
	echo ""                                            >> $$t1_cpp_path ; \
	echo "t000001::"                                   >> $$t1_cpp_path ; \
	echo "t000001 ( ) : "                              >> $$t1_cpp_path ; \
	echo "    tester::test ( \"t000001\", \"Basic test 1\" ) {} " >> $$t1_cpp_path ; \
	echo ""                                            >> $$t1_cpp_path ; \
	echo ""                                            >> $$t1_cpp_path ; \
	echo "void"                                        >> $$t1_cpp_path ; \
	echo "t000001::"                                   >> $$t1_cpp_path ; \
	echo "run ( ) throw ( number::fault )  { "         >> $$t1_cpp_path ; \
	echo ""                                            >>  $$t1_cpp_path ; \
	echo "    log_in (t000001) ;"                      >> $$t1_cpp_path ; \
	echo "                      "                      >> $$t1_cpp_path ; \
	echo "                      "                      >> $$t1_cpp_path ; \
	echo "                      "                      >> $$t1_cpp_path ; \
	echo "    log_out (t000001) ;"                      >> $$t1_cpp_path ; \
	echo "}"                                            >> $$t1_cpp_path ; \
	# assembling the name of the t000002.cpp                             ; \
	t2_cpp_name="t000002.cpp"                                            ; \
	t2_cpp_path="$(dir_code)/test/$$t2_cpp_name"                         ; \
	# writing to t000002.cpp                                             ; \
	echo "#include \"$$header_name\""                       > $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo "using namespace tenacitas::$$namespace_test;" >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo "const number::fault::code t000002::erro1 ( 100 ) ;" >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo "t000002::"                                   >> $$t2_cpp_path ; \
	echo "t000002 ( ) : "                              >> $$t2_cpp_path ; \
	echo "    tester::test ( \"t000002\", \"Basic test 2\" ) {} " >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo "void"                                        >> $$t2_cpp_path ; \
	echo "t000002::"                                   >> $$t2_cpp_path ; \
	echo "run ( ) throw ( number::fault )  { "         >> $$t2_cpp_path ; \
	echo ""                                            >> $$t2_cpp_path ; \
	echo "    // this tenacitas::tests examples what should be done when a test fails" >> $$t2_cpp_path ; \
	echo "    log_in (t000002) ;"                      >> $$t2_cpp_path ; \
	echo "                      "                      >> $$t2_cpp_path ; \
	echo "    // and throw the tenacitas::number::fault" >> $$t2_cpp_path ; \
	echo "    throw ( create_fault ( t000002, erro1 ) ) ;" >> $$t2_cpp_path ; \
	echo "                      "                      >> $$t2_cpp_path ; \
	echo "    log_out (t000002) ;"                      >> $$t2_cpp_path ; \
	echo "}"                                            >> $$t2_cpp_path ; \
	# assembling the name of the tests_interface.cpp file                 ; \
	itf_name="tests_interface.cpp"                                       ; \
	# assembling the path of the tests_interface.cpp file                ; \
	itf_path="$(dir_code)/test/$$itf_name"                               ; \
	# writing to tests_interface.cpp file                                ; \
	echo "#include \"$$header_name\""                      >> $$itf_path ; \
	echo "#include <tenacitas.tester/tester.h>"            >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "using namespace std;"                            >> $$itf_path ; \
	echo "using namespace tenacitas::$$namespace_test;"    >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "/**"                                             >> $$itf_path ; \
	echo "   Creates the tenacitas::tester::tests "        >> $$itf_path ; \
	echo " */"                                             >> $$itf_path ; \
	echo "extern \"C\" tenacitas::tester::tests * tests_create ( ) {">> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "    // here we create the tenacitas::tester::tests pointer, defining a name for" >> $$itf_path ; \
	echo "    // the group of tests"                       >> $$itf_path ; \
	echo "    tenacitas::tester::tests * l_tests = "       >> $$itf_path ; \
	echo "        new tenacitas::tester::tests ( \"Testing $(project)\" ) ;">> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "    // and here we add the tenacitas::tester::test objects that implement the" >> $$itf_path ; \
	echo "    // unit tests"                               >> $$itf_path ; \
	echo "    if ( l_tests ) {"                            >> $$itf_path ; \
	echo "        l_tests->add ( new t000000 ( ) ) ;"      >> $$itf_path ; \
	echo "        l_tests->add ( new t000001 ( ) ) ;"      >> $$itf_path ; \
	echo "        l_tests->add ( new t000002 ( ) ) ;"      >> $$itf_path ; \
	echo "    }"                                           >> $$itf_path ; \
	echo "   // finaly, we deliver a tenacitas::tester::tests to the application" >> $$itf_path ; \
	echo "    return l_tests;"                             >> $$itf_path ; \
	echo "}"                                               >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "/**"                                             >> $$itf_path ; \
	echo "   Destroys the tenacitas::tester::tests "       >> $$itf_path ; \
	echo " */"                                             >> $$itf_path ; \
	echo "extern \"C\" void tests_destroy (tenacitas::tester::tests ** p_tests ) {"  >> $$itf_path ; \
	echo ""                                                >> $$itf_path ; \
	echo "    if ( *p_tests ) {"                           >> $$itf_path ; \
	echo "        delete *p_tests;"                        >> $$itf_path ; \
	echo "        *p_tests = 0;"                           >> $$itf_path ; \
	echo "    }"                                           >> $$itf_path ; \
	echo "}"                                               >> $$itf_path 



# Creates the necessary files to build the test as a library
test_as_lib:
	$(show) ""                                                           ; \
	make project=$(project) verbose=$(verbose)                             \
		test_as_lib_change_project_file                              ; \
	make project=$(project) test_as_lib_create_test_file                 ; 



#                           PUBLIC

#@public@|test_clean|Cleans the Test of the Project
#@public_detailed@|test_clean|Syntax: 'make project=<project-name> [coc=<cpu-os-compiler>] [verbose=0/1]  [target=debug/release] test_clean
#@public_detailed@|test_clean|Where <project-name> is an existing project. Please rum 'make prj_list' to list all the avaiable projects.
#@public_detailed@|test_clean|Where <cpu-os-compiler> is the name of a file that contain definitions for a CPU, OS and compiler. Please, run 'make coc_list' to list all the combinations avaiables.
test_clean : 
	$(show) ""                                                                       ; \
	echo "********************************************* "                            ; \
	echo "Cleaning test for $(project)"                                              ; \
	rm -f $(dir_test)/*.o  2> /dev/null                                              ; \
	rm -f $(dir_test)/*~ 2> /dev/null                                                 ; \
	rm -f $(dir_bin)/$(program_prefix)$(project)_test$(program_sufix) 2> /dev/null   ; 


# setup

#@public@|test_compile|Compiles the Test of the Project
#@public_detailed@|test_compile|Syntax: 'make project=<project-name> [coc=<cpu-os-compiler>] [verbose=0/1]  [target=debug/release] test_compile
#@public_detailed@|test_compile|Where <project-name> is an existing project. Please rum 'make prj_list' to list all the avaiable projects.
#@public_detailed@|test_compile|Where <cpu-os-compiler> is the name of a file that contain definitions for a CPU, OS and compiler. Please, run 'make coc_list' to list all the combinations avaiables.
test_compile : setup $(test_objs)



#@public@|test_build|Builds the Test of the Project
#@public_detailed@|test_build|Syntax: 'make project=<project-name> [coc=<cpu-os-compiler>] [verbose=0/1]  [target=debug/release] test_build
#@public_detailed@|test_build|Where <project-name> is an existing project. Please rum 'make prj_list' to list all the avaiable projects.
#@public_detailed@|test_build|Where <cpu-os-compiler> is the name of a file that contain definitions for a CPU, OS and compiler. Please, run 'make coc_list' to list all the combinations avaiables.
#@public_detailed@|test_build|If in 'tenacitas.build_system/bin/<project-name>/tool/gmake/project.mk' is defined that 'test_type' is '$(library)', this command will generate a program library called '$(shared_prefix)<project-name>.test.$(shared_sufix)' and will place it in '$(build_lib_dir)', defined in 'tenacitas.build_system/tool/gmake/cpu_os_comp/<cpu-os-compiler>.mk'
#@public_detailed@|test_build|If in 'tenacitas.build_system/bin/<project-name>/tool/gmake/project.mk' is defined that 'test_type' is '$(program)', this command will generate a program library called '$(program_prefix)<project-name>.test.$(program_sufix)' and will place it in '$(build_bin_dir)'. 
##@public_detailed@|test_build|$(build_lib_dir), $(build_bin_dir), $(program_prefix), $(program_prefix), $(shared_prefix) and $(shared_sufix) are defined in 'tenacitas.build_system/tool/gmake/cpu_os_comp/<cpu-os-compiler>.mk'

# setup 
test_build : code_build test_compile
	$(show) ""                                                           ; \
	echo "********************************************* "                ; \
	echo "Builing test for  $(project)"                                  ; \
	if [ $(test_type) = $(program) ]; then                                 \
		$(make_cmd) -s test_build_pgm                                ; \
	else                                                                   \
		if [ $(test_type) = $(library) ]; then                         \
			$(make_cmd) test_build_lib                           ; \
		fi                                                           ; \
	fi                                                                   ;

#@public@|test_build|Builds the code of all projects that this project depends on, then the code of all projects that this test depend on, and then the test
#@public_detailed@|test_build|Syntax: 'make project=<project-name> [coc=<cpu-os-compiler>] [verbose=0/1]  [target=debug/release] test_build
#@public_detailed@|test_build|Where <project-name> is an existing project. Please rum 'make prj_list' to list all the avaiable projects.
#@public_detailed@|test_build|Where <cpu-os-compiler> is the name of a file that contain definitions for a CPU, OS and compiler. Please, run 'make coc_list' to list all the combinations avaiables.
#@public_detailed@|test_build|If in 'tenacitas.build_system/bin/<project-name>/tool/gmake/project.mk' is defined that 'test_type' is '$(library)', this command will generate a program library called '$(shared_prefix)<project-name>.test.$(shared_sufix)' and will place it in '$(build_lib_dir)', defined in 'tenacitas.build_system/tool/gmake/cpu_os_comp/<cpu-os-compiler>.mk'
#@public_detailed@|test_build|If in 'tenacitas.build_system/bin/<project-name>/tool/gmake/project.mk' is defined that 'test_type' is '$(program)', this command will generate a program library called '$(program_prefix)<project-name>.test.$(program_sufix)' and will place it in '$(build_bin_dir)'. 
##@public_detailed@|test_build|$(build_lib_dir), $(build_bin_dir), $(program_prefix), $(program_prefix), $(shared_prefix) and $(shared_sufix) are defined in 'tenacitas.build_system/tool/gmake/cpu_os_comp/<cpu-os-compiler>.mk'
test_build_chain : code_build_chain  test_code_build_chain
	$(show) ""                                                           ; \
	echo "********************************************* "                ; \
	$(make_cmd) test_build                                               ;

#@public@|test_cfg|Configures the test for the project
#@public_detailed@|test_cfg|Syntax: 'make project=<project-name> [verbose=0/1] test_cfg test_type=[lib/pgm]
#@public_detailed@|test_cfg|This determines if the test should generate a library, to be loaded by one of the 'tenacitas.tester_*.e' programs, or if it should generate a program
#@public_detailed@|test_cfg|Please, read the documentation of 'tenacitas.tester' to understand how to create tests as libraries.
test_cfg:
	$(show) ""                                                           ; \
	echo "********************************************* "                ; \
	echo "Configuring test for $(project)"                               ; \
	if [ $(test_type) = "lib" ]; then                                      \
		make project=$(project) verbose=$(verbose) test_as_lib       ; \
	else                                                                   \
		make project=$(project) verbose=$(verbose) test_as_pgm       ; \
	fi                                                                   ;

